#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
数据预处理MCP服务使用示例

本文件展示了如何使用数据预处理服务的各项功能：
1. 文件数据处理（CSV、Excel、文本）
2. 直接数据处理（JSON、列表、矩阵）
3. 数据格式验证
4. 排序数据转换
5. 数据信息获取

每个示例都包含详细的说明和预期输出。
"""

import asyncio
import json
import os
import tempfile
from pathlib import Path
from typing import Any, Dict

import pandas as pd

# 导入服务器模块
from server import (
    process_file_data,
    process_direct_data,
    validate_data_format,
    convert_ranking_data,
    get_data_info
)

def print_section(title: str):
    """打印章节标题"""
    print("\n" + "="*60)
    print(f" {title}")
    print("="*60)

def print_result(result, title: str = ""):
    """格式化打印结果"""
    if title:
        print(f"\n{title}:")
        print("-" * len(title))
    
    if result.isError:
        print(f"❌ 错误: {result.content[0]['text']}")
    else:
        try:
            content = json.loads(result.content[0]['text'])
            print(json.dumps(content, ensure_ascii=False, indent=2))
        except:
            print(result.content[0]['text'])

async def example_file_data_processing():
    """示例1: 文件数据处理"""
    print_section("示例1: 文件数据处理")
    
    # 创建临时目录和测试文件
    temp_dir = tempfile.mkdtemp()
    
    # 1. 创建CSV测试文件
    print("\n1.1 创建CSV测试文件")
    csv_data = pd.DataFrame({
        'Treatment_A': [23, 25, 27, 29, 31],
        'Treatment_B': [18, 20, 22, 24, 26],
        'Treatment_C': [15, 17, 19, 21, 23],
        'Control': [12, 14, 16, 18, 20]
    })
    csv_file = os.path.join(temp_dir, 'treatment_data.csv')
    csv_data.to_csv(csv_file, index=False)
    print(f"CSV文件已创建: {csv_file}")
    print("数据内容:")
    print(csv_data)
    
    # 1.2 处理CSV文件为groups格式（用于Kruskal-Wallis检验）
    print("\n1.2 转换为groups格式（多组独立样本）")
    args = {
        "file_path": csv_file,
        "output_format": "groups"
    }
    result = await process_file_data(args)
    print_result(result, "Groups格式输出")
    
    # 1.3 创建Excel测试文件
    print("\n1.3 创建Excel测试文件")
    excel_file = os.path.join(temp_dir, 'repeated_measures.xlsx')
    repeated_data = pd.DataFrame({
        'Subject': [f'S{i+1}' for i in range(8)],
        'Condition_1': [12, 15, 18, 21, 14, 17, 20, 23],
        'Condition_2': [14, 17, 20, 23, 16, 19, 22, 25],
        'Condition_3': [16, 19, 22, 25, 18, 21, 24, 27],
        'Condition_4': [18, 21, 24, 27, 20, 23, 26, 29]
    })
    repeated_data.to_excel(excel_file, index=False)
    print(f"Excel文件已创建: {excel_file}")
    print("数据内容:")
    print(repeated_data)
    
    # 1.4 处理Excel文件为matrix格式（用于Friedman检验）
    print("\n1.4 转换为matrix格式（重复测量数据）")
    args = {
        "file_path": excel_file,
        "output_format": "matrix",
        "group_columns": ['Condition_1', 'Condition_2', 'Condition_3', 'Condition_4']
    }
    result = await process_file_data(args)
    print_result(result, "Matrix格式输出")
    
    # 1.5 创建文本文件
    print("\n1.5 创建文本文件（制表符分隔）")
    text_file = os.path.join(temp_dir, 'binary_data.txt')
    binary_text = "0\t1\t0\t1\n1\t0\t1\t0\n0\t0\t1\t1\n1\t1\t0\t0\n"
    with open(text_file, 'w', encoding='utf-8') as f:
        f.write(binary_text)
    print(f"文本文件已创建: {text_file}")
    print("数据内容:")
    print(binary_text)
    
    # 1.6 处理文本文件为binary_matrix格式（用于Cochran检验）
    print("\n1.6 转换为binary_matrix格式（二分类数据）")
    args = {
        "file_path": text_file,
        "output_format": "binary_matrix",
        "file_options": {"delimiter": "\t"}
    }
    result = await process_file_data(args)
    print_result(result, "Binary Matrix格式输出")

async def example_direct_data_processing():
    """示例2: 直接数据处理"""
    print_section("示例2: 直接数据处理")
    
    # 2.1 处理JSON格式数据
    print("\n2.1 处理JSON格式数据")
    json_data = {
        "Group_A": [12, 14, 16, 18, 20],
        "Group_B": [15, 17, 19, 21, 23],
        "Group_C": [18, 20, 22, 24, 26]
    }
    print("输入数据:")
    print(json.dumps(json_data, ensure_ascii=False, indent=2))
    
    args = {
        "data": json_data,
        "output_format": "groups"
    }
    result = await process_direct_data(args)
    print_result(result, "转换为groups格式")
    
    # 2.2 处理列表格式数据
    print("\n2.2 处理列表格式数据（已分组）")
    list_data = [
        [1.2, 1.5, 1.8, 2.1],
        [2.3, 2.6, 2.9, 3.2],
        [3.4, 3.7, 4.0, 4.3]
    ]
    print("输入数据:")
    print(list_data)
    
    args = {
        "data": list_data,
        "output_format": "groups",
        "data_structure": "groups"
    }
    result = await process_direct_data(args)
    print_result(result, "保持groups格式")
    
    # 2.3 处理矩阵数据
    print("\n2.3 处理矩阵数据（重复测量）")
    matrix_data = [
        [12, 15, 18, 21],  # 被试1
        [14, 17, 20, 23],  # 被试2
        [16, 19, 22, 25],  # 被试3
        [18, 21, 24, 27],  # 被试4
        [20, 23, 26, 29]   # 被试5
    ]
    print("输入数据:")
    print(matrix_data)
    
    args = {
        "data": matrix_data,
        "output_format": "matrix"
    }
    result = await process_direct_data(args)
    print_result(result, "Matrix格式输出")
    
    # 2.4 转换为二分类数据
    print("\n2.4 转换为二分类数据")
    continuous_data = [
        [0.3, 0.7, 0.2, 0.8],
        [0.6, 0.4, 0.9, 0.1],
        [0.5, 0.8, 0.3, 0.7]
    ]
    print("输入数据（连续值）:")
    print(continuous_data)
    
    args = {
        "data": continuous_data,
        "output_format": "binary_matrix",
        "binary_threshold": 0.5
    }
    result = await process_direct_data(args)
    print_result(result, "二分类转换结果（阈值=0.5）")

async def example_data_validation():
    """示例3: 数据格式验证"""
    print_section("示例3: 数据格式验证")
    
    # 3.1 验证Kruskal-Wallis检验数据
    print("\n3.1 验证Kruskal-Wallis检验数据格式")
    kw_data = [
        [12, 14, 16, 18, 20],
        [15, 17, 19, 21, 23],
        [18, 20, 22, 24, 26]
    ]
    print("数据:")
    print(kw_data)
    
    args = {
        "data": kw_data,
        "target_service": "exact_test",
        "test_type": "kruskal_wallis"
    }
    result = await validate_data_format(args)
    print_result(result, "Kruskal-Wallis验证结果")
    
    # 3.2 验证Friedman检验数据
    print("\n3.2 验证Friedman检验数据格式")
    friedman_data = [
        [12, 15, 18, 21],
        [14, 17, 20, 23],
        [16, 19, 22, 25],
        [18, 21, 24, 27]
    ]
    print("数据:")
    print(friedman_data)
    
    args = {
        "data": friedman_data,
        "target_service": "approximation_test",
        "test_type": "friedman"
    }
    result = await validate_data_format(args)
    print_result(result, "Friedman验证结果")
    
    # 3.3 验证Cochran检验数据
    print("\n3.3 验证Cochran检验数据格式")
    cochran_data = [
        [1, 0, 1, 0],
        [0, 1, 0, 1],
        [1, 1, 0, 0],
        [0, 0, 1, 1]
    ]
    print("数据:")
    print(cochran_data)
    
    args = {
        "data": cochran_data,
        "target_service": "exact_test",
        "test_type": "cochran_q"
    }
    result = await validate_data_format(args)
    print_result(result, "Cochran验证结果")
    
    # 3.4 验证无效数据
    print("\n3.4 验证无效数据格式")
    invalid_data = "这不是有效的数据格式"
    print("数据:")
    print(invalid_data)
    
    args = {
        "data": invalid_data,
        "target_service": "exact_test",
        "test_type": "kruskal_wallis"
    }
    result = await validate_data_format(args)
    print_result(result, "无效数据验证结果")

async def example_ranking_data_conversion():
    """示例4: 排序数据转换"""
    print_section("示例4: 排序数据转换")
    
    # 4.1 电视排名数据（来自用户提供的示例）
    print("\n4.1 电视排名数据转换")
    tv_ranking_data = [
        [12, 9, 2, 4, 10, 7, 11, 6, 8, 5, 3, 1],  # 机构I
        [10, 1, 3, 12, 8, 7, 5, 9, 6, 11, 4, 2],  # 机构II
        [11, 8, 4, 12, 2, 10, 9, 7, 5, 6, 3, 1],  # 机构III
        [9, 1, 2, 10, 12, 6, 7, 4, 8, 5, 11, 3]   # 机构IV
    ]
    
    evaluator_names = ["机构I", "机构II", "机构III", "机构IV"]
    tv_names = [f"电视{chr(65+i)}" for i in range(12)]  # A-L
    
    print("原始排名数据:")
    print("评价机构:", evaluator_names)
    print("电视型号:", tv_names)
    for i, ranking in enumerate(tv_ranking_data):
        print(f"{evaluator_names[i]}: {ranking}")
    
    args = {
        "ranking_data": tv_ranking_data,
        "output_format": "matrix",
        "evaluator_names": evaluator_names,
        "object_names": tv_names
    }
    result = await convert_ranking_data(args)
    print_result(result, "排名数据转换结果（matrix格式）")
    
    # 4.2 转换为groups格式
    print("\n4.2 转换为groups格式（按电视型号分组）")
    args = {
        "ranking_data": tv_ranking_data,
        "output_format": "groups",
        "evaluator_names": evaluator_names,
        "object_names": tv_names
    }
    result = await convert_ranking_data(args)
    print_result(result, "排名数据转换结果（groups格式）")
    
    # 4.3 简单排名数据
    print("\n4.3 简单排名数据示例")
    simple_ranking = [
        [1, 2, 3, 4, 5],  # 评价者1
        [2, 1, 4, 3, 5],  # 评价者2
        [1, 3, 2, 5, 4],  # 评价者3
        [2, 1, 3, 4, 5]   # 评价者4
    ]
    
    print("简单排名数据:")
    for i, ranking in enumerate(simple_ranking):
        print(f"评价者{i+1}: {ranking}")
    
    args = {
        "ranking_data": simple_ranking,
        "output_format": "matrix"
    }
    result = await convert_ranking_data(args)
    print_result(result, "简单排名转换结果")

async def example_data_info():
    """示例5: 数据信息获取"""
    print_section("示例5: 数据信息获取")
    
    # 5.1 分析矩阵数据
    print("\n5.1 分析矩阵数据")
    matrix_data = [
        [12, 15, 18, 21],
        [14, 17, 20, 23],
        [16, 19, 22, 25],
        [18, 21, 24, 27],
        [20, 23, 26, 29]
    ]
    print("矩阵数据:")
    for row in matrix_data:
        print(row)
    
    args = {"data": matrix_data}
    result = await get_data_info(args)
    print_result(result, "矩阵数据信息")
    
    # 5.2 分析字典数据
    print("\n5.2 分析字典数据")
    dict_data = {
        "treatment_A": [23, 25, 27, 29, 31],
        "treatment_B": [18, 20, 22, 24, 26],
        "control": [12, 14, 16, 18, 20]
    }
    print("字典数据:")
    print(json.dumps(dict_data, ensure_ascii=False, indent=2))
    
    args = {"data": dict_data}
    result = await get_data_info(args)
    print_result(result, "字典数据信息")
    
    # 5.3 分析列表数据
    print("\n5.3 分析列表数据")
    list_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print("列表数据:")
    print(list_data)
    
    args = {"data": list_data}
    result = await get_data_info(args)
    print_result(result, "列表数据信息")

async def example_complete_workflow():
    """示例6: 完整工作流程"""
    print_section("示例6: 完整工作流程")
    
    print("\n场景：研究人员有一组实验数据，需要进行Kruskal-Wallis检验")
    
    # 6.1 原始数据
    raw_data = {
        "control_group": [12, 14, 16, 18, 20, 22],
        "treatment_1": [15, 17, 19, 21, 23, 25],
        "treatment_2": [18, 20, 22, 24, 26, 28],
        "treatment_3": [21, 23, 25, 27, 29, 31]
    }
    
    print("\n6.1 原始实验数据:")
    print(json.dumps(raw_data, ensure_ascii=False, indent=2))
    
    # 6.2 获取数据信息
    print("\n6.2 分析数据特征")
    info_args = {"data": raw_data}
    info_result = await get_data_info(info_args)
    print_result(info_result, "数据特征分析")
    
    # 6.3 转换为groups格式
    print("\n6.3 转换为Kruskal-Wallis检验所需的groups格式")
    convert_args = {
        "data": raw_data,
        "output_format": "groups"
    }
    convert_result = await process_direct_data(convert_args)
    print_result(convert_result, "数据格式转换")
    
    # 6.4 验证转换后的数据
    print("\n6.4 验证数据是否适用于精确检验")
    if not convert_result.isError:
        converted_data = json.loads(convert_result.content[0]['text'])['data']
        validate_args = {
            "data": converted_data,
            "target_service": "exact_test",
            "test_type": "kruskal_wallis"
        }
        validate_result = await validate_data_format(validate_args)
        print_result(validate_result, "数据验证结果")
        
        # 6.5 同时验证近似检验
        print("\n6.5 验证数据是否适用于近似检验")
        validate_args["target_service"] = "approximation_test"
        validate_result2 = await validate_data_format(validate_args)
        print_result(validate_result2, "近似检验验证结果")
    
    print("\n✅ 工作流程完成！数据已准备好用于统计检验。")

async def main():
    """主函数 - 运行所有示例"""
    print("🔬 数据预处理MCP服务使用示例")
    print("本示例展示了如何使用数据预处理服务处理各种类型的数据")
    print("并将其转换为非参数统计检验服务可识别的格式。")
    
    try:
        # 运行所有示例
        await example_file_data_processing()
        await example_direct_data_processing()
        await example_data_validation()
        await example_ranking_data_conversion()
        await example_data_info()
        await example_complete_workflow()
        
        print_section("总结")
        print("\n🎉 所有示例运行完成！")
        print("\n主要功能：")
        print("• 📁 文件数据处理：支持CSV、Excel、文本文件")
        print("• 🔢 直接数据处理：支持JSON、列表、矩阵格式")
        print("• ✅ 数据格式验证：确保数据符合检验要求")
        print("• 📊 排序数据转换：专门处理排名/评价数据")
        print("• 📈 数据信息分析：提供数据统计摘要")
        print("\n输出格式：")
        print("• groups: 多组独立样本（Kruskal-Wallis, Jonckheere-Terpstra）")
        print("• matrix: 重复测量矩阵（Friedman, Kendall, Page, Durbin）")
        print("• binary_matrix: 二分类矩阵（Cochran Q）")
        print("\n兼容服务：")
        print("• Accurate_sample_approximation_test（近似检验）")
        print("• Accurate_samples_exact_test（精确检验）")
        
    except Exception as e:
        print(f"\n❌ 示例运行出错: {e}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    # 运行示例
    asyncio.run(main())